PCMania 64/PCMania CD64_1.iso/phy/phy004/files/articulo.t06

Text File | 1996-11-14 | 11.2 KB | 207 lines

ε      Curso de assembler (IV)π

  Vamos a continuar en esta nueva entrega con algo más fuertecillo... después
de presentar el δA86π (incluido en este número), daremos un profundo repaso a
las principales interrupciones para luego poder iniciar proyectos más
complejos. Pero empezemos corrigiendo los programitas que puse el pasado dia:

Γ MOV     AX, 100  ; AX=100π
Γ MOV     BX, 200  ; BX=200π
Γ ADD     AX, BX   ; AX=300π
Γ MUL     BX       ; DX:AX=200*300=60000π

  Este era un ejemplo muy sencillo que no tenia ningún tipo de error ni
complicación más allá de lo normal. El próximo os ha dado problemas a alguno
pues lo intentasteis compilar y no os dejó:

Γ MOV     AX, 30   ; AX=30π
Γ MOV     BX, 10   ; BX=10π
Γ MUL     BX       ; DX:AX=30*10=300π
Γ DIV     BX       ; DX=0 AX=30     π
Γ ADD     AL, BX   ; ERROR!!!       π

  La última instrucción da un error de compilación ya que no se puede sumar
un número de 8 bits con otro de 16. El último de los problemitas tampoco se
podia compilar por varios errores:

Γ MOV     AL, 500  ; ERROR!!!π
Γ MOV     BL, 100  ; BL=100  π
Γ SUB     AL, BL   ; AL=AL-100π
Γ MUL     10       ; ERROR!!! π

  En la primera línea ya nos encontramos un error bastante gordo, pero muy
frequente al principio que consiste en tratar de meter en un registro de 8
bits (en este caso) un valor de más bits (al menos 9 para el 500). La solución
seria usar AX que puede representar hasta 16 bits. El otro error que aparece
es la multiplicación que se intenta hacer en la última línea y que es ilegal
ya que no podemos multiplicar por un valor constante.

ε      El ensamblador A86π

  El δA86π es un ensamblador shareware que nos permitirá crear código para el
procesador 8086 que es el que estamos "estudiando" aquí. No se trata de un
ensamblador completísimo, con miles de opciones para hacer virguerias, es un
programita de lo más simple en el mundo de los ensambladores, pero esa sim-
plicidad, lejos de hacerlo inferior, provoca que se use siempre que se desee
hacer un programita rápido.
  Lo usaremos durante unos meses ya que durante la fase de aprendizaje es mejor
dejarse de complicaciones, por lo que seria recomendable que si dominas el
inglés te leas los manuales que, por cierto, llevan un curso básico de assem-
bler. Tambien deberias de registrarte si te gusta y lo vas a usar, aunque yo
no creo que lo hagas... como todos.  :)
  Vamos con la sintáxis. ¿Recordais los programitas de antes? Pues podeis
probar a teclearlos y ensamblarlos... no hace falta que le digais nada más,
el assembler lo ha sobre-entendido todo. Como ejemplo he metido un archivo
llamado 'δaritmet1.asmπ' en el directorio '∞ASMπ' que podeis compilar y luego
debuggear con el própio 'δdebugπ' del DOS.
  Como podreis observar, el δA86π es tan simple que consta de un sólo ejecuta-
ble que podeis incluso (por su reducido tamaño) copiar al directorio del DOS o
si no lo preferiis poner en la variable δPATHπ del sistema la ruta hasta donde
se encuentra dicho fichero. Además del δA86π, existe un debugger llamado D86 y
creado por la misma persona que lee los ficheros δ.SYMπ generados y nos ayuda
a debuggear (tal vez en próximos números se incluya el δD86π).
  Los comentarios en el δA86π, como en todos los ensambladores, consisten en un
punto y coma y de ahí a final de línea es ignorado. Hay unas cuantas directivas
para el ensamblador que no veremos si no nos son necesarias y de las que po-
dreis ver una referencia en los δ.DOCπ que se adjuntan. Otra cosita bastante
simple del A86 son las etiquetas, una etiqueta es cualquier secuencia de carac-
teres válida acabada en 'Γ:π' (dos puntos). Un ejemplo de uso de etiquetas lo
podeis ver en 'δaritmet2.asmπ' que es un ejemplo algo más complejo que estu-
diaremos ahora enseguida.

ε      Instrucciones de bifurcaciónπ

  Tras ese pomposo nombre se esconden ni más ni menos que los saltos que se
producen durante la ejecución del programa. Está clarísimo que no se puede
programar de forma lineal y por tanto el procesador ha de proporcionarnos una
forma de hacer que el programa siga su curso por otro camino que no sea la
línea recta. Las causas de salto pueden ser: interrupciones (tanto software
como hardware), llamadas a subrutinas, saltos condicionales y saltos
incondicionales. Vamos a ver, por orden inverso, los saltitos:
    Los saltos incondicionales son los que produce el programador para cambiar
la ejecución del programa a otro punto por la razón que sea. La instrucción
que se encarga de hacerlo es ΓJMPπ que es el acrónimo de ∞JUMPπ (salto). Vamos
con el ejemplo:

Γ   MOV  AX, 100     [1]π
Γ   MOV  BX, 200     [2]π
Γ   JMP  Suma        [3]π
Γ Fin:               [4]π
Γ   MOV  AX,4C00h    [5]π
Γ   INT  21h         [6]π
Γ Suma:              [7]π
Γ   ADD  AX, BX      [8]π
Γ   JMP  Fin         [9]π

 Este sencillísimo código lo que hace es primero guardar 2 valores inmediatos
en ΓAXπ y ΓBXπ (lineas 1 y 2), luego saltar con la instrucción ∞JMPπ a la eti-
queta 'δSumaπ' que se encuentra en la línea 7, se suman los números y se salta
a la línea 4 donde se ejecutan las 2 líneas que terminan la ejecución de los
programas.
 Como podrás ver, la instrucción δJMPπ es el δGOTOπ de Basic, C, Pascal y tan-
tos lenguajes de alto nivel que siempre nos prohibieron usar (pero que aquí es
lo único que se puede emplear para determinadas cosas).
    Los saltos condicionales son un tipo especial de salto que se ejecutan se-
gún el estado que la anterior instrucción haya dejado en el registro de flags
o banderas. Antes de nada, el registro de estado (de flags o como te de la ga-
na), es un registro que no se debe modificar y que guarda información de la
ejecución de la última instrucción, bueno, no exactamente la última, la última
que haya modificado el registro de estado, es decir, algunas lo modifican y
otras no (en general lo modifican las que pasan pasan por la δALUπ, las aritmé-
ticas). Este registro guarda información sobre como si, por ejemplo, los dos
registros implicados en una resta han dado resultado cero, o negativo, etc.
Bueno, veamos un ejemplo y luego sigo:

Γ   MOV  AX, 40          [ 1]π
Γ   MOV  BX, 20          [ 2]π
Γ   SUB  AX, BX          [ 3] π
Γ   JZ   Fin             [ 4] π
Γ   SUB  AX, BX          [ 5] π
Γ   JZ   Fin2            [ 6] π
Γ Fin:                   [ 7] π
Γ   MOV  AX, 4C00h       [ 8] π
Γ   INT  21h             [ 9] π
Γ Fin2:                  [10] π
Γ   JMP  Fin             [11] π

 En el ejemplo lo primero que se hace es poner en δAXπ y δBXπ los valores ini-
ciales, luego se hace la resta δAX-BXπ que da como resultado ΓAX=40-20=20π y
en el registro de estado se pone el bit correspondiente como que el resultado
φNOπ es cero. En la línea 4 aparece la primera línea de salto condicional que
viene a decir aproximadamente "Σsi el resultado de la operación 'ΓSUB AX,BXΣ'π
Σera 0, entoces saltar a 'ΓFinΣ', en otro caso, continuar por la siguiente lí-π
Σnea (5)π". Como el resultado no habia dado 0, no se salta y se continua con la
ejecución de la línea 5 que es otra resta, pero que en esta ocasión, sí resulta
ser cero. La línea 6 es análoga a la 4, pero resulta que la anterior instruc-
ción sí habia dado como resultado 0 y por tanto habrá que saltar a la etiqueta
'ΓFin2π'. La etiqueta 'ΓFin2π' nos lleva a la instrucción 'ΓJMP Finπ' que salta
incondicionalmente a la línea 7 donde se termina el programa con las típicas
instrucciones.
 Muchas veces, nos interesará saltar si 2 registros son iguales, pero no que-
rremos perder el contenido de uno de ellos, para esto hay una instrucción que
es ΓCMPπ y que es el acrónimo de COMPARE. Básicamente lo que hace es restar los
2 registros que se indiquen, pero sin escribir el resultado en el destino. Como
te podrás imaginar, para saber si los 2 registros son iguales, hay que mirar
si despues de restarlos el resultado es 0 (con el bit de cero del registro de
flags). La lista completa de instrucciones de salto condicional ya las veremos,
pero las más importantes son (aunque algunas como δJZπ y δJEπ sean iguales):
Γ   JZ  ->  si ceroπ
Γ   JE  ->  si igualesπ
Γ   JC  ->  si lleva acarreoπ
Γ   JB  ->  si menor que    π
Γ   JA  ->  si mayor que    π
Γ   JS  ->  si es negativo  π
 NOTA: Se puede intercalar la letra 'ßNπ' para indicar negación, por ejemplo,
       ΓJEπ salta si son iguales y ΓJNEπ salta si no son iguales.
    Las llamadas a subrutinas son el tercer tipo de salto que veremos. Se usa
la instrucción ΓCALLπ (llamar) seguida por una etiqueta y es equivalente a la
instrucción de δBASICπ (o otros lenguajes lineales) ΓGOSUBπ. Lo que se hace internamente
es muy importante e interesante, pero no lo veremos hasta que sepamos que es
la pila. En este número sólo veremos un ejemplo y dejaré para más adelante el
estudio concienzudo de los subprogramas:

Γ  MOV  AX, 100   ;  Inicializamos AX y BXπ
Γ  MOV  BX, 80    ; a un valor cualquiera.π
Γ  CALL Suma      ;  Llamamos a Suma.     π
Γ  MOV  AX, 4C00h ;  En DX ahora tendremos laπ
Γ  INT  21h       ; suma de AX y BX.         π
Γ Suma:                                      π
Γ  MOV  DX, AX    ;  Subprograma para sumar 2π
Γ  ADD  DX, BX    ; números.                 π
Γ  RET            ;  Instrucción para regresarπ

    El último tipo de bifurcaciones son las interrupciones. Básicamente se
trata de subprogramas predefinidos a los que se llama para realizar una tarea
en concreto (mostrar un mensaje, salir al DOS, etc). No me extenderé más en
esto ya que en el pasado número ya tuvisteis el primer contacto y más adelante
tendreis otro contacto.
  Con estos saltos que habeis podido ver, el programador ya puede empezar a
estructurar sus programas tal como lo hacia con los δHLLπ y compactar aún más
sus programas. Recomendaria que los programitas de ejemplo que he mostrado,
los compilarais y los ejecutarais paso a paso para ver por donde va el curso
de instrucciones en cada momento.

ε      Las principales interrupcionesπ

  Como hay muchas interrupciones para hacer muy variadas cosas, lo mejor es
que consigais la lista de δRalf Brownπ o algo similar y busqueis la interrupción
adecuada para lo que vayais a hacer. Por ejemplo, si necesitais abrir ficheros
y manejar su contenido, le deciis al programa que busque "Γopen fileπ" o algo
por el estilo y encontrareis un servicio (Ω3Dhπ) dentro de la δINT 21hπ que os
permitirá abrir ficheros. A partir de este, mirais los servicios asociados y
encontrareis como cerrar el fichero (Ω3Ehπ), como posicionarte (Ω42hπ), etc.
  Iba a hacer una lista de los mejores, pero como seguro que todos teneis o
podeis conseguir la lista esta de R.B. pues no lo he hecho. De todas formas si
teneis problemas encontrandola o no os aclarais con alguna interrupción, no
dudeis en preguntar. Para que tengais unos ejemplos más, os he incluido un
sencillo código que lo que hace es decir si existe o no un fichero. Prueba a
crear y eliminar el fichero y debuggea el programa para ver que hace en cada
instante.

   Como el tiempo apremia por culpa de los malditos exámenes, no he podido
hacer más ejemplos ni explicar las instrucciones lógicas, pero en el próximo
número seguro que tendreis mucha más chicha que en este... practicad mucho y
no seais malos (=no programeis en Visual Basic :)

                                                       ∞ Navi Dj.π